Deklaration eines Funktionsbausteins in ST

Syntax
FUNCTION_BLOCK (* optional_begin *) FINAL|ABSTRACT (* optional_end *) FB_name_2
 
(* optional_begin *) USING Namespace_1;
USING Namespace_2; (* optional_end *)
 
(* optional_begin *) EXTENDS FB_name_1 (* optional_end *)

(* optional_begin *) EXTENDS class_name_1 (* optional_end *)

 
(* optional_begin *) IMPLEMENTS interface_1, interface_2, ... interface_n (* optional_end *)
 
(* optional: declaration of variables/instances *)
 
(* optional: declaration of methods *)
 
(* optional: body of function block *)
 
END_FUNCTION_BLOCK
Bedeutung

Deklaration eines →Funktionsbausteins, wobei FB_name_2 ein →IEC-Bezeichner sein muss.
Die Deklaration ist in einem ST-Objekt und in einer ST-Schnittstelle eines C-/C++-Bausteins möglich – darin erfolgt die Deklaration entweder im globalen →Namespace oder in einem deklarierten Namespace. FUNCTION_BLOCK und END_FUNCTION_BLOCK sind die →Schlüsselwörter für die Deklaration des Funktionsbausteins.

Neuron Power Engineer unterstützt die folgenden Varianten an Funktionsbausteinen:

  1. Der Funktionsbaustein enthält nur einen Satz an Operationen (den sogenannten Body).
    In diesem Fall enthält der Funktionsbaustein keine Methoden.

  2. Der Funktionsbaustein enthält den Body und →Methoden.
    Eine Methode ist ähnlich zu einer →Funktion; Eine Methode kann nur im →Gültigkeitsbereich eines →Funktionsbaustein-Typ definiert werden und hat impliziten Zugang zu den →statischen Variablen der →Funktionsbaustein-Instanz. Eine Methode wird nach dem Abschnitt der deklarierten →Variablen/→Instanzen, aber vor dem Body des Funktionsbausteins deklariert.

  3. Der Funktionsbaustein enthält nur Methoden.
    In diesem Fall enthält der Funktionsbaustein einen leeren Body.

Die Schlüsselwörter FINAL und ABSTRACT (Features der →objektorientierte Programmierung) sind optional. Siehe "Deklaration einer Methode" für ein Beispiel mit einem abstrakten/finalen Funktionsbaustein.

  • Verwenden Sie das Schlüsselwort FINAL, falls der aktuelle Funktionsbaustein nicht als Basis-Funktionsbaustein verwendet werden soll und von dem in Folge nicht abgeleitet werden kann. Siehe Schlüsselwort EXTENDS für Details über Basis-Funktionsbaustein und abgeleiteten Funktionsbaustein.

  • Verwenden Sie das Schlüsselwort ABSTRACT, falls der aktuelle Funktionsbaustein ein Basis-Funktionsbaustein sein soll, von dem abgeleitet wird. Es gelten diese Einschränkungen/Folgen:

    • Ein abstrakter Funktionsbaustein darf nicht instanziiert werden.

    • Ein abstrakter Funktionsbaustein muss zumindest eine abstrakte Methode enthalten.

    • Als Folge muss ein nicht-abstrakter Funktionsbaustein, der von einem abstrakten Funktionsbaustein abgeleitet wird, alle abstrakten Methoden des abstrakten Funktionsbausteins implementieren.

Die USING-Namespace-Anweisung nach dem Namen des Funktionsbaustein ist ebenfalls optional. Siehe "Namespaces in ST: Verwendung" für Details für diese Anweisung.

Das Schlüsselwort EXTENDS (ein Feature der →objektorientierte Programmierung) ist ebenfalls optional. Geben Sie EXTENDS an, falls der Funktionsbaustein von einem anderen Funktionsbaustein (dem Basis-Funktionsbaustein) oder von einer →Klasse (der Basis-Klasse) abgeleitet werden soll. Den Namen des Basis-Funktionsbausteins oder der Klasse geben Sie hinter EXTENDS an.
Die Auswirkungen des Schlüsselwort EXTENDS sind:

  • Der abgeleitete Funktionsbaustein FB_name_2 erbt alle Variablen und Methoden vom Basis-Funktionsbaustein FB_name_1 oder der Klasse class_name_1. Sie können natürlich eigene Variablen und Methoden im abgeleiteten Funktionsbaustein deklarieren. In Folge kann der abgeleitete Funktionsbaustein die vererbten Variablen und Methoden als auch die eigenen Variablen und Methoden verwenden.
    Ausnahme von dieser Vererbung sind jene Methoden, die mit dem Schlüsselwort PRIVATE oder INTERNAL im Basis-Funktionsbaustein oder in der Basis-Klasse deklariert sind.

  • Wenn in der folgenden Beschreibung von EXTENDS ein Basis-Funktionsbaustein erwähnt wird und der Kontext auch auf eine Klasse angewendet werden kann, so gilt die Beschreibung auch für eine Basis-Klasse. Bei Unklarheiten bezüglich der Auswirkungen von EXTENDS auf/für Klassen kontaktieren Sie Neuron).

  • Sie müssen eindeutige Namen für alle Variablen und Methoden im abgeleiteten Funktionsbaustein und im jeweiligen Basis-Funktionsbausteinen verwenden.

  • Der Basis-Funktionsbaustein selbst kann jedoch ein abgeleiteter Funktionsbaustein sein. So können Variablen und Methoden über mehrere Ebenen von Funktionsbaustein zu Funktionsbaustein weiter vererbt werden. Eine Rekursion wird laut der IEC-Norm nicht unterstützt.

  • Wird der Basis-Funktionsbaustein geändert, erben die abgeleiteten Funktionsbausteine diese Änderungen über die entsprechenden Ebenen hinweg.

  • Weitere Einschränkungen:

  • Ein Funktionsbaustein darf nur von einem Basis-Funktionsbaustein abgeleitet werden. Dieser Basis-Funktionsbaustein muss ein anderer Funktionsbaustein sein. Ein abgeleiteter Funktionsbaustein darf nicht von mehreren Basis-Funktionsbausteinen gleichzeitig erben – dies wird von der IEC-Norm nicht unterstützt.

  • Ein Funktionsbaustein darf nur von einem Basis-Funktionsbaustein abgeleitet werden, wenn dieser Basis-Funktionsbaustein Methoden enthält. Die Methoden können auch über mehrere Ebenen hinweg enthalten sein, sofern der Basis-Funktionsbaustein wiederum ein abgeleiteter Funktionsbaustein ist usw.

  • Der abgeleitete Funktionsbaustein erbt nicht automatisch den Body des Basis-Funktionsbausteins. Damit beim Aufruf eines abgeleiteten Funktionsbausteins auch der Body des abgeleiteten Funktionsbausteins ausgeführt wird, müssen Sie die Anweisung SUPER(); im Body des abgeleiteten Funktionsbausteins einfügen. Siehe das folgende Beispiel 3.
    Einschränkungen für SUPER();:

    • SUPER(); ist nur in einem abgeleiteten Funktionsbaustein zulässig, also nur falls das Schlüsselwort EXTENDS beim Funktionsbaustein angegeben ist.

    • SUPER(); darf nur einmal im Body des abgeleiteten Funktionsbausteins angegeben werden. In Folge ist SUPER(); auch nicht in Wiederholungsanweisungen zulässig.

    • SUPER(); darf in Methoden zum Aufruf einer Methode nicht verwendet werden. Verwenden Sie stattdessen einen der Aufrufe einer Methode.

  • Alternative zu SUPER();: Verlagern Sie den Body des Basis-Funktionsbausteins in eine deklarierte Methode dieses Basis-Funktionsbausteins und rufen Sie diese Methode im abgeleiteten Funktionsbaustein auf. Siehe das folgende Beispiel 4.

Das Schlüsselwort IMPLEMENTS (ein Feature der →objektorientierte Programmierung) ist ebenfalls optional. Geben Sie IMPLEMENTS an, falls der Funktionsbaustein ein oder mehrere →Interfaces implementieren soll. Die Namen der Interfaces geben Sie hinter IMPLEMENTS an (durch einen Beistrich voneinander getrennt).

Beachten Sie, dass der Funktionsbaustein in Folge alle Methoden der Interfaces enthalten muss. Ist dies nicht der Fall, weist eine Meldung auf die fehlenden Methoden hin. Verwenden Sie am besten die Schnellkorrektur von Neuron Power Engineer, um die nicht-implementierten Methoden im Funktionsbaustein hinzuzufügen. Die konkreten Methoden, die im Funktionsbaustein deklariert sind, werden mit den abstrakten Methoden abgeglichen, die in den Interfaces deklariert sind. Das Abgleichen erfolgt nur aufgrund des Namens der Methode. Die Methoden mit dem gleichen Namen müssen in den folgenden Aspekte übereinstimmen:

  • Falls ein Datentyp erforderlich ist, muss der Datentyp in der abstrakten Methode und in der konkreten Methode angegeben sein. Der Datentyp muss vom gleichen Typ sein.
    Ist kein Datentyp erforderlich, darf der Datentyp weder in der abstrakten noch in der abstrakten Methode angegeben sein.

  • Alle Variablen, die in der abstrakten Methode deklariert sind, müssen mit den Variablen übereinstimmen, die in der konkrete Methode deklariert sind.

Beispiel 1: Funktionsbaustein ohne Body und ohne Methoden
FUNCTION_BLOCK Control
END_FUNCTION_BLOCK
Beispiel 2: Funktionsbaustein, der Interfaces implementiert
INTERFACE ISwitch     (* declaration of the 1st interface *)
  METHOD SwitchState
    VAR_INPUT
      STATE : BOOL;
    END_VAR
  END_METHOD
END_INTERFACE
 
INTERFACE IValve      (* declaration of the 2nd interface *)
  METHOD Open
  END_METHOD 
END_INTERFACE
 
FUNCTION_BLOCK MySwitch IMPLEMENTS ISwitch, IValve
  VAR
    switchState : BOOL;
    valveOpen : BOOL;
  END_VAR
  METHOD PUBLIC SwitchState
    VAR_INPUT
    STATE : BOOL;
  END_VAR
    switchState := STATE;
  END_METHOD
  METHOD PUBLIC Open
    valveOpen := TRUE;
  END_METHOD 
END_FUNCTION_BLOCK
Beispiel 3: Abgeleiteter Funktionsbaustein und Basis-Funktionsbaustein
FUNCTION_BLOCK LightRoom (* the base function block "LightRoom" *)
    VAR
        Light : BOOL;
    END_VAR
    VAR_INPUT
        Daytime : BOOL;
    END_VAR
 
    METHOD PUBLIC M1 : INT
        m1:=2;
    END_METHOD
 
    Light := NOT(Daytime);
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK FB_A
    METHOD PUBLIC m1 : INT
        m1 := 1;
    END_METHOD
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK Light2Room
    EXTENDS LightRoom (* the derived function block "Light2Room" *)
    VAR
        Light2 : BOOL; // 2. Licht
        Inst1 : FB_A;
        v1, v2, v3 : INT;
    END_VAR
 
    METHOD PUBLIC OVERRIDE M1 : INT
        m1 := 3;
    END_METHOD
 
    METHOD PUBLIC M2
    END_METHOD
 
    SUPER(); // The body of the base function block "LightRoom" is called here.
    Light2:= NOT(Daytime);
 
    v1 := SUPER.M1(); // The method "M1" of the base function block "LightRoom" is called here.
    v2 := THIS.M1();  // The method "M1" of the current function block "Light2Room" is called here.
    v3 := Inst1.M1(); // The method "M1" of the function block instance 'Inst1' (= function block 'FB_A') is called here.
END_FUNCTION_BLOCK
Beispiel 4: Abgeleiteter Funktionsbaustein und Basis-Funktionsbaustein
FUNCTION_BLOCK FB1  (* the base function block "FB1" *)
    VAR
        Var1 : INT;
    END_VAR
 
    METHOD PUBLIC InitFB1
        Var1 := 5;
    END_METHOD
 
    InitFB1();      (* call of the method "InitFB1" *)
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK FB2 EXTENDS FB1 (* the derived function block "FB2" *)
    VAR
        Var2 : INT;
    END_VAR
 
    METHOD PUBLIC InitFB2
        Var2 := 5;
        InitFB1();  (* call of the method "InitFB1" of the base function block "FB1" - identical to the call of the method within the base function block itself *)
    END_METHOD
 
    InitFB2();      (* call of the method "InitFB2" of the derived function block "FB2" *)
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK FB3 
    VAR
        iFB2 : FB2;
    END_VAR
 
    iFB2();         (* call of the instance for the derived function block type "FB2" *)
END_FUNCTION_BLOCK

In einem Funktionsbaustein dürfen Sie die folgenden Sprachelemente für ST verwenden:

Durch die Verwendung von Sprachelementen können Sie auch andere Elemente (z.B. Deklaration von STRING-Variablen im Abschnitt VAR ... END_VAR) verwenden. Dieses Elemente sind in der obigen Liste nicht angeführt.